//一个文件只能用一个public,且类名与文件名需要一致
//java字符类型采用Unicode编码，每个Unicode码占用16个比特拉
//java中标识符为：字母 数字 _ $
// 注意(标识符不能以数字或者是关键字开头，且要区分大小写）


//用于定义访问权限修饰符的关键字 private protected public
// 用于定义类，函数，变量修饰符的关键字 abstract final static synchronized
// 用于定义类与类之间关系的关键字 extends implements
// 用于定义建立实例及引用实例，判断实例的关键字 new this httr super instanceof
// 用于异常处理的关键字 try catch finally throw throws
// 用于包的关键字 package import
// 其他修饰符关键字 native strictfp transient volatile assert

public class J20250224{
    public static void main1(String[] args) {
        int a = 10;
        System.out.println(a);
    }

    public static void main2(String[] args) {
        System.out.println("自动换行");
        System.out.print("不换行");
        System.out.printf("%s\n","手动换行");
    }


//数据类型   字节型      短整型          整型         长整型           单精度浮点型  双精度浮点型   字符型      布尔型
//关键字     byte      short          int          long            float      double      char      boolean
//包装类型   Byte       Short        Integer       Long            Float      Double     Character   Boolean
//内存占用    1字节      2字节         4字节          8字节            4字节       8字节        2字节      无明确
//范围    -128~127  -32768~32767  -2^31~2^31-1  -2^63~2^63-1       不关注      不关注      0~65535   ture和false
// 1个字节(byte)为8个二进制位（bit)
//定义变量语法格式  数据类型 变量名 = 初始值





    //字节型
    public static void main3(String[] args) {
        byte a = 126;
        System.out.println(a);//这一行打印结果为126 并没有超出范围
        System.out.println(Byte.MIN_VALUE);//这行与下一行解释byte类型的范围，这一行打印结果为-128
        System.out.println(Byte.MAX_VALUE);//这一行打印结果为127

    }

    //double在任何系统中都是占8个字节
    public static void main4(String[] args) {
        double d = 12.5;//小数不能精确到每一位  只能精确到后几位 示例如下
        System.out.println(d);//打印出 12.5
        System.out.println(Double.MIN_VALUE);//4.9E-324
        System.out.println(Double.MAX_VALUE);//1.7976931348623157E308

    }

    public static void main5(String[] args) {
        double num =1.1;//理想情况下double类型小数精确到15到16位，所以浮点数只是一个近似值，并不是精确值
        System.out.println(num * num);//打印结果为1.2100000000000002

    }


    public static void main6(String[] args) {
        double a = 1.0;//    由于int和double存储类型不同，若这里用int a = 1
        double b = 2.0;//                                   int b = 2
        System.out.println(a/b);//除法中a和b都不能为0         则结果打印不为0.5

    }
    //float在java中占用4个字节，表示的精度范围较小所以优先考虑double
    public static void main7(String[] args) {
        float f = 12.5f;//由于12.5默认为double类型所以会报错，只需在12.5后面加上f即可
        System.out.println(f);//12.5
        System.out.println(Float.MIN_VALUE);//1.4E-45
        System.out.println(Float.MAX_VALUE);//3.4028235E38

    }
    //字符型
    public static void main8(String[] args) {
        char ch = 'a';
        char ch2 = 97;
        char ch3 = '8';//java语言中字符可以存放整型
        char ch4 = '嗨';//一个汉字两个字节
        System.out.println(ch);//a
        System.out.println(ch2);//a
        System.out.println(ch3);//8
        System.out.println(ch4);//嗨

    }

    //布尔类型
    public static void main9(String[] args) {
        boolean flg = true;//在java语言的布尔类型中，只能使用true或者是false,有别于C语言中0为假，非0为真。
        System.out.println(flg);//ture

    }





//类型转换：java作为一个强类型编程语言，当不同类型之间的变量相互赋值的时候，会有较严格的校验
// 将⼀个字⾯值常量进⾏赋值的时候,Java会⾃动针对数字范围进⾏检查
// 强制类型转换不⼀定能成功，不相⼲的类型不能互相转换，比如布尔类型就不行

    public static void main10(String[] args) {
        int a = 10;//4个字节
        long b = 100L;//为了区分数字1，这里通常用大写字母L 8字节
        b = a;//可编译，若写成a = b则编译失败，此时需要强制类型转换
        a = (int)b;//此为强转，有风险可能丢失数据
        System.out.println(a);//10
        System.out.println(b);//10

    }

    //第一种：强制（隐式）类型转换：当进⾏操作时，代码需要经过⼀定的格式处理，不能⾃动完成。
    //                   特点：数据范围⼤的到数据范围⼩的
    public static void main11(String[] args) {
        int a = 10;
        long b = 100L;
        b = a; // int-->long，数据范围由⼩到⼤，隐式转换
        a = (int)b; // long-->int, 数据范围由⼤到⼩，需要强转，否则编译失败
        System.out.println("a = " + a);//a=10
        System.out.println("b = " + b);//b=10

        float f = 3.14F;
        double d = 5.12;
        d = f; // float-->double，数据范围由⼩到⼤，隐式转换
        f = (float)d; // double-->float, 数据范围由⼤到⼩，需要强转，否则编译失败
        System.out.println("d = " + d);//d=3.140000104904175
        System.out.println("f = " + f);//f=3.14

        byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
        byte b2 =(byte)257; // 257默认为int，超过byte范围，需要显⽰转换，否则报错
        System.out.println(b1);//100
        System.out.println(b2);//b2=1   之所以打印结果为1是因为这里发生了溢出，byte最大能存储的就是127，将128复制给byte的时候，就会溢出，变成-128，129赋值给byte就是-127，算一下257，最终溢出就是1

    }
    //第二种：自动（显式）类型转换：代码不需要经过任何处理，在代码编译时，编译器会⾃动进⾏处理。
    //                   特点：数据范围⼩的转为数据范围⼤的时会⾃动进⾏。
    public static void main12(String[] args) {
        System.out.println(1024); // 整型默认情况下是int
        System.out.println(3.14); // 浮点型默认情况下是double
        int a = 100;
        long b = 10L;
        b = a; //int 类型的值 ⾃动转换为了long类型
        System.out.println("a = " + a);//a=100
        System.out.println("b = " + b);//b=100

        float f = 3.14F;
        double d = 5.12;
        d = f; //float 类型的值 ⾃动转换为了double 类型
        System.out.println("d = " + d);//d=3.140000104904175
        System.out.println("f = " + f);//f=3.14

    }



//类型提升：不同类型的数据之间相互运算时，数据类型⼩的会被提升到数据类型⼤的。

    //1. int与long之间：int会被提升为long
    public static void main13(String[] args) {
        int a = 10;
        long b = 20;
        long c = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long ,若写成int c = a + b则编译失败会丢失数据
        System.out.println(a + b);//30

    }
    //2. byte与byte的运算
    public static void main14(String[] args) {
        byte a = 10;
        byte b = 20;
        //byte c = a + b;    编译错误 虽然a和b都是byte,但是计算a+b会先将a和b都提升成int,再进⾏计算,得到的结果也是int,这是赋给c,就会出现上述错误
        byte c = (byte)(a + b);//算机的CPU通常是按照4个字节为单位从内存中读写数据.为了硬件上实现⽅便,诸如byte和short这种低于4个字节的类型,会先提升成int,再参与计算
        System.out.println(c);//30
    }



//字符串类型 Java中使⽤String类定义字符串类型

    public static void main15(String[] args) {
        String s1 = "hello";
        String s2 = "world";//也可以在此处写成" world",这样s1+s2就是hello world
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1 + " " + s2);//hello world 与下面打印不同的是中间拼接了空格
        System.out.println(s1+s2); //helloworld s1+s2表⽰：将s1和s2进⾏拼接,java 中字符串可以进行拼接

    }
    //注意+是拼接如下容易混淆的例子
    public static void main16(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a+b= " + a+b);//此处结果为a+b=1020，并非a+b= 30，+号是拼接并非运算
        System.out.println(a+b + "hahaha");//此处结果为30hahaha
        System.out.println("a+b= " + (a + b));//此处打印结果才是a+b=30,第一个+是拼接，第二个+是运算，加括号表示优先级先计算了a+b的结果
    }

    //在有些情况下，需要将字符串和整型数字之间进⾏转换
    //1.int,double转成String
    public static void main17(String[] args) {
        int num = 10;
        String str1 = num + "";// ⽅法1
        System.out.println(str1);//10

        String str2 = String.valueOf(num);//方法2
        System.out.println(str2);//10

        int i = 123456;
        String str3 = String.valueOf(123456);//方法2
        System.out.println(str3);//123456

        double d = 3.14;
        String str4 = String.valueOf(3.14);//方法2
        System.out.println(str4);//3.14

    }
    //2.String转换为int
    public static void main18(String[] args) {
        String str = "100";
        int num = Integer.parseInt(str);//将字符串100转换为了int类型100
        System.out.println(num + 1);//101

        String str2 = "6";
        float f = Float.parseFloat(str2);//将字符串3转换为float类型3.0
        System.out.println(f + 1);//7.0

        String str3 = "3.14";
        double d = Double.parseDouble(str3);//将字符串3.14转换为double类型
        System.out.println(d + 1);//4.140000000000001


    }

}